package com.yunsom.testdemo.multiple_thread.concurrent_tools;

import java.util.concurrent.*;

public class ConcurrentToolsTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
      //  Executors
      //      Executor 是一个简单的标准接口，可以用于定义类似线程的子系统，包括线程池、异步IO、轻量级任务框架等
      //      ExecutorService 提供了一个更为完整的异步执行框架。它管理任务队列和定时执行，并且支持停止运行。提供了支持得到异步返回
      //          结果的Callable任务，通过Future返回结果。
      //      ThreadPoolExecutor 和 ScheduledThreadPoolExecutor 提供了可调优的、弹性的线程池实现。
      //      Executors 工具类提供了创建各种线程池的工厂方法以及一些使用线程池的工具方法
      //      ForkJoinPool设计用于处理ForkJoinTask和它的子类，它们实现了“工作窃取”定时执行器。
      ExecutorService threadPoolExecutor = new ThreadPoolExecutor(
              8,
              20,
              60,
              TimeUnit.SECONDS,
              new LinkedBlockingDeque<>(1024),
              Executors.defaultThreadFactory(),
              new RejectedExecutionHandler() {
                  @Override
                  public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                      System.out.println("task is rejected, maybe shutdown?, r: " + r.toString());
                  }
              }
      );
      ExecutorTest.main(null);

      // Queues 提供了一些阻塞或非阻塞的队列
      //      提供了阻塞队列BlockingQueue的5个实现，定义了阻塞版本的put和take。不同的实现覆盖了生产者-消费者、消息处理、
      //          并行任务及其他相关并发设计
      //      BlockingQueue
      // 并发集合
      //      ConcurrentHashMap
      ConcurrentHashMapTest.main(null);
      //      CopyOnWriteArrayList COW
      CopyOnWriteArrayListTest.main(null);
      //      CopyOnWriteArraySet
      //      ConcurrentLinkedQueue 不会阻塞的队列，高效的可扩展,线程安全,基于链表实现的FIFO队列（LinkedList的并发版本）

      // Timing 时间单位
      //      TimeUnit 提供了不同粒度的时间单位，用于指定和控制基于时间的操作

      // Synchronizers  同步器（信号量-控制同时访问的线程个数）

      // 并发实用工具
      // Semaphore
      //      翻译成字面意思为 信号量，Semaphore 可以控制同时访问的线程个数，通过acquire() 获取一个许可，
      //      如果没有就等待，而 release() 释放一个许可。
      //      Semaphore 类中比较重要的几个方法：
      //        1. public void acquire(): 用来获取一个许可，若无许可能够获得，则会一直等待，直到获得许可。
      //        2. public void acquire(int permits):获取 permits 个许可
      //        3. public void release() { } :释放许可。注意，在释放许可之前，必须先获获得许可。
      //        4. public void release(int permits) { }:释放 permits 个许可
      //      上面 4 个方法都会被阻塞，如果想立即得到执行结果，可以使用下面几个方法
      //        1. public boolean tryAcquire():尝试获取一个许可，若获取成功，则立即返回 true，若获取失
      //        败，则立即返回 false
      //        2. public boolean tryAcquire(long timeout, TimeUnit unit):尝试获取一个许可，若在指定的
      //        时间内获取成功，则立即返回 true，否则则立即返回 false
      //        3. public boolean tryAcquire(int permits):尝试获取 permits 个许可，若获取成功，则立即返
      //        回 true，若获取失败，则立即返回 false
      //        4. public boolean tryAcquire(int permits, long timeout, TimeUnit unit): 尝试获取 permits
      //        个许可，若在指定的时间内获取成功，则立即返回 true，否则则立即返回 false
      //        5. 还可以通过 availablePermits()方法得到可用的许可数目。
      SemaphoreTest.main(null);

      // CountDownLatch 是一个非常简单但非常通用的实用程序，用于阻塞直到给定数量的信号，事件或条件成立。


      // CyclicBarrier 是可重置的多路同步点，在某些并行编程样式中很有用。


      // Phaser 提供了一种更灵活的屏障形式，可用于控制多个线程之间的分阶段计算。


      // Exchanger 允许两个线程在集合点交换对象，并且在几种管道设计中很有用。


      // atomic包

      // Lock

      // Condition

      // 可重入锁 ReentrantLock

      // 读写锁 ReadWriteLock

      // LockSupport

      // 原子操作类

    }
}
